# Create Queries

`create` and `create_many` allow you to easily create one or many records.

A model's required fields need to be provided as individual arguments to the arguments of `create` or in a tuple for `create_many',
whereas optional fields can be provided in a Vec after all the required fields.

When providing the value of an optional field, it is necessary to wrap the value in a 'field identifier' so that the client
knows which field to set. These usually look like `model::field::set`.
This is not required for required fields as they get their own position in the argument list.

Nested creates are not supported yet.

The examples use the following schema:

```prisma
generator client {
    provider = "cargo prisma"
    output = "src/prisma.rs"
}

model Post {
    id        String   @id @default(cuid())
    createdAt DateTime @default(now())
    updatedAt DateTime @updatedAt
    published Boolean
    title     String
    content   String?
    desc      String?

    comments Comment[]
}

model Comment {
    id        String   @id @default(cuid())
    createdAt DateTime @default(now())
    content   String

    post   Post   @relation(fields: [postID], references: [id])
    postID String
}
```

## Create

The following example creates a post and overwrites its autogenerated `id` field.

```rust
use prisma::post;

let post: post::Data = client
    .post()
    .create(
        // Required fields are individual arguments.
        // Wrapping their values is not necessary.
        true,
        "what up".to_string(),
        // All other fields can be passed in the last argument
        vec![
            // Generated fields can be overwritten like regular fields
            post::id::set("id".to_string()),
            // Non-required fields require being wrapped in an Option
            post::content::set(Some("content".to_string()))
        ]
    )
    .exec()
    .await?;
```

### Connecting Relations

The `connect` function of a relation field module can be used to connect new records with existing ones.
It takes a single unique filter as an argument.

The following example creates a new comment and links it to a post.

```rust
use prisma::{comment, post};

let comment: comment::Data = client
    .comment()
    .create(
        "content".to_string(),
        // If post wasn't required, then this would need
        // to be wrapped in comment::post::connect(..).
        post::id::equals("id".to_string())
        vec![]
    )
    .exec()
    .await?;
```


Connecting records like this is equivalent to directly setting the values of the relation's foreign keys, eg.
setting `post_id` from the above example with `comment::post_id::set()`.


## Create Unchecked

_Available since v0.6.7_

`create_unchecked` is similar to `create` but only allows setting scalar fields using `UncheckedSetParam`.
`unchecked` is a Prisma term describing inputs that only accept a model's scalar fields.

```rust
use prisma::{comment, post};

let comment: comment::Data = client
    .comment()
    .create_unchecked(
        "content".to_string(),
		// requires providing value for postID foreign key,
		// rather than connecting a relation
        0,
        vec![]
    )
    .exec()
    .await?;
```

## Create Many

`create_many` can be used to create many records of a single model type.
It accepts a `Vec` of tuples with the same shape as `create_unchecked`,
so only scalar fields can be set.

import { Callout } from "nextra/components"

<Callout type="info">
	SQLite support for `create_many` is **UNSTABLE**,
	but can be enabled by adding the `sqlite-create-many` feature to `prisma-client-rust` and `prisma-client-rust-cli` in your `Cargo.toml` files.
</Callout>

To assist in constructing tuples of the right shape,
each model module contains a `create_unchecked` function that accepts a model's scalar fields and returns the correct tuple.

The following example iterates an array of titles, turns it into tuples and creates multiple posts.

```rust
use prisma::post;

let titles = [
    "Title 1",
    "Title 2",
    "Title 3"
]

let posts: i64 = client
    .post()
    .create_many(
        titles
            .iter()
            .map(|title| post::create_unchecked(
                true,
                title.to_string(),
                vec![]
            ))
            .collect() // Necessary to create a Vec
    )
    .exec()
    .await?;
```

### Skip Duplicates

The `create_many` builder has a `skip_duplicates` function which can be used to stop an
error from being thrown if a unique constraint is violated,
instead conflicting records will be ignored and the rest will be created.

```rust
client
    .post()
    .create_many(..)
    .skip_duplicates() // No error if unique violation is broken
    .exec()
    .await?
```
